#!/usr/bin/env python
# -*- coding: utf-8 -*-

# day 01
# 1.操作系统的作用?
'''
应用程序软件工作在操作系统上，操作系统负责支配硬件进行工作。
'''

# 2.列举你听过的操作系统及区别？
'''
windows：win7、win8、win10、server 2003、server 2008、server 2012 /图形化界面友好，占用资源多，适合简单办公
linux：CentOS、ubuntu、redhat /图形化界面差，占用资源少，适合做服务器
MacOS /贵，系统优化好，适合办公
'''

# 3.列举你了解的编码及他们之间的区别？
'''
ASCII：英文编码，使用1字节=8位
unicode：万国码，能解译现有文明的文字，占用磁盘空间高，使用4字节=32位
utf-8：万国码的升级优化版，合理占用磁盘空间，使用1-4字节，中文占用3字节
gbk/gb2312：中文编码，中文占用2字节。
'''

# 4.列举你了解的Python2和Python3的区别？
'''
1.py2解释器默认编码是ASCII编码 / py3解释器默认是utf-8
2.py2输出语句 print '' / py3输出语句 print('')
3.py2输入语句 raw_input('') / py3输入语句 input('')
4.py2有int/long两种整数类型 / py3只有int类型
5.py2除法不能取小数位 / py3除法可以取小数位
'''

# 5.你了解的python都有那些数据类型？
'''
1.int
2.str
3.list
4.tuple
5.dict
6.set
'''

# 6.补充代码，实现以下功能。
'''
value = 'alex烧饼'
print(value)  # 要求输出  alex"烧饼
'''

# 7.用print打印出下面内容：
"""
print('''⽂能提笔安天下,
武能上⻢定乾坤.
⼼存谋略何⼈胜,
古今英雄唯是君。''')
"""

# 8.变量名的命名规范和建议？
'''
1.只能使用字母、数字、'_'
2.不能使用数字开头
3.不能使用关键字
建议：见名知意
'''

# 9.如下那个变量名是正确的？
'''
name = '武沛齐' # True
_ = 'alex'      # True
_9 = "老男孩"   # True
9name = "景女神"# False
oldboy(edu = 666# False
'''

# 10.简述你了解if条件语句的基本结构。
'''
if 判断条件:
    符合条件的操作
elif 如果符合这个判断条件:
    符合条件的操作
else:
    都不符合条件的操作。
'''

# 11.设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；
# 如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确。
'''
i = int(input('你猜我的理想数字是多少：'))
if i > 66:
    print('大了')
elif i < 66:
    print('小了')
else:
    print('猜对了')
'''

# 12.提⽰⽤户输入⿇花藤. 判断⽤户输入的对不对。如果对, 提⽰真聪明, 如果不对, 提⽰你 是傻逼么。
'''
s = input('请输入麻花藤')
if s == '麻花藤':
    print('真聪明')
else:
    print('是傻逼么')
'''

# day 02
# 1.猜数字，设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；
# 如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确，然后退出循环。
'''
while True:
    s = int(input('请输入我的理想数字：'))
    if s > 66:
        print('大了')
    elif s < 66:
        print('小了')
    else:
        print(s)
        break
'''

# 2.在上一题的基础，设置：给用户三次猜测机会，如果三次之内猜测对了，
# 则显示猜测正确，退出循环，如果三次之内没有猜测正确，则自动退出循环，并显示‘大笨蛋’。
'''
count = 0
while True:
    if count == 3:
        print('大笨蛋')
    s = int(input('请输入我的理想数字：'))
    if s > 66:
        print('大了')
        count += 1
    elif s < 66:
        print('小了')
        count += 1
    else:
        print(s)
        break
'''

# 3.使用两种方法实现输出 1 2 3 4 5 6 8 9 10 。

'''
for i in range(1, 11):
    if i == 7:
        continue
    else:
        print(i)
'''
'''
for i in range(1, 7):
    print(i)
for i in range(8, 11):
    print(i)
'''

# 4.求1-100的所有数的和
'''
tatol = 0
for i in range(1, 101):
    tatol += i
print(tatol)
'''

# 5.输出 1-100 内的所有奇数
'''
tatol = 0
for i in range(1, 101):
    if i % 2 == 0:
        continue
    else:
        tatol += i
print(tatol)
'''

# 6.输出 1-100 内的所有偶数
'''
tatol = 0
for i in range(1, 101):
    if i % 2 == 1:
        continue
    else:
        tatol += i
print(tatol)
'''

# 7.求1-2+3-4+5 ... 99的所有数的和
'''
tatol = 0
for i in range(0, 100):
    if i % 2 == 1:
        tatol += i
    else:
        tatol -= i
print(tatol)
'''

# 8.⽤户登陆（三次输错机会）且每次输错误时显示剩余错误次数（提示：使⽤字符串格式化）
'''
for i in range(3, 0, -1):
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    if user == 'alex' and pwd == '123':
        print('登陆成功')
        break
    else:
        print('用户名或密码错误，您有三次错误机会，当前还剩%s次' % (i - 1))
'''

# 9.简述ASCII、Unicode、utf-8编码
'''
ASCII：英文编码，使用1字节=8位
unicode：万国码，能解译现有文明的文字，占用磁盘空间高，使用4字节=32位
utf-8：万国码的升级优化版，合理占用磁盘空间，使用1-4字节，中文占用3字节
'''

# 10.简述位和字节的关系？
'''
1字节（Byte） = 8位（bit）
'''

# 11.猜年龄游戏
'''
age = int(input('你猜猜我多大了：'))
if age == 18:
    print('恭喜你猜对了')
elif age > 18:
    print('大了')
else:
    print('小了')
'''

# 12.猜年龄游戏升级版 要求：允许用户最多尝试3次，每尝试3次后，如果还没猜对，
# 就问用户是否还想继续玩，如果回答Y，就继续让其猜3次，以此往复，如果回答N，就退出程序，如何猜对了，就直接退出。
'''
count = 0
while True:
    age = int(input('你猜猜我多大了：'))
    if age == 18:
        print('恭喜你猜对了')
        break
    elif age > 18:
        print('大了')
    else:
        print('小了')
    count += 1
    if count == 3:
        agent = input('是否继续 Y/N：')
        if agent.upper() == 'N':
            break
        elif agent.upper() == 'Y':
            count = 0
'''

# 13.判断下列逻辑语句的True,False
'''
1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 # False
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 # False
'''

# 14.求出下列逻辑语句的值。
'''
8 or 3 and 4 or 2 and 0 or 9 and 7 # 8
0 or 2 and 3 and 4 or 6 and 0 or 3 # True
'''

# 15.下列结果是什么？
'''
6 or 2 > 1 # 6
3 or 2 > 1 # 3
0 or 5 < 4 # 0
5 < 4 or 3 # 3
2 > 1 or 6 # True
3 and 2 > 1 # 3
0 and 3 > 1 # True
2 > 1 and 3 # 3
3 > 1 and 0 # 0
3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2 # False
'''

# day 03
# 1.有变量name = "aleX leNb " 完成如下操作：
# 移除 name 变量对应的值两边的空格,并输出处理结果
'''
name = "aleX leNb "
print(name.strip())
'''
# 判断 name 变量是否以 "al" 开头,并输出结果（用切片）
'''
name = "aleX leNb "
print(name[0:2])
'''
# 判断name变量是否以"Nb"结尾,并输出结果（用切片）
"""
name = "aleX leNb "
print(name[-2:])
"""
# 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
"""
name = "aleX leNb "
print(name.replace('l', 'p'))
"""
# 将name变量对应的值中的第一个"l"替换成"p",并输出结果
"""
name = "aleX leNb "
print(name.replace('l', 'p', 1))
"""
# 将 name 变量对应的值根据 所有的"l" 分割,并输出结果
"""
name = "aleX leNb "
print(name.split('l'))
"""
# 将name变量对应的值根据第一个"l"分割,并输出结果
"""
name = "aleX leNb "
print(name.split('l', 1))
"""
# 将 name 变量对应的值变大写,并输出结果
"""
name = "aleX leNb "
print(name.upper())
"""
# 将 name 变量对应的值变小写,并输出结果
"""
name = "aleX leNb "
print(name.lower())
"""
# 请输出 name 变量对应的值的第 2 个字符?
"""
name = "aleX leNb "
print(name[1])
"""
# 请输出 name 变量对应的值的前 3 个字符?
"""
name = "aleX leNb "
print(name[0:3])
"""
# 请输出 name 变量对应的值的后 2 个字符?
"""
name = "aleX leNb "
print(name[-2:])
"""

# 2.有字符串s = "123a4b5c"
# 通过对s切片形成新的字符串 "123"
"""
s = "123a4b5c"
print(s[0:3])
"""
# 通过对s切片形成新的字符串 "a4b"
"""
s = "123a4b5c"
print(s[3:6])
"""
# 通过对s切片形成字符串s5,s5 = "c"
"""
s = "123a4b5c"
s5 = s[-1]
print(s5)
"""
# 通过对s切片形成字符串s6,s6 = "ba2"
"""
s = "123a4b5c"
s6 = s[-3::-2]
print(s6)
"""

# 3.使用while循环字符串 s="asdfer" 中每个元素。
"""
s="asdfer"
count = 0
while count < len(s):
    print(s[count])
    count += 1
"""

# 4.使用while循环对s="321"进行循环，打印的内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"，"出发！"。
"""
s="321"
count = 0
while True:
    if count == 3:
        print('出发')
        break
    print('倒计时%s秒' % (s[count]))
    count += 1
"""

# 5.实现一个整数加法计算器(两个数相加)：
# 如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9（含空白）
# ，然后进行分割转换最终进行整数的计算得到结果。
"""
sum = input('请输入内容:')
sum1 = sum.strip().split('+')
print(int(sum1[0]) + int(sum1[1]))
"""

# 6.计算用户输入的内容中有几个 h 字符？
# 如：content = input("请输入内容：") # 如fhdal234slfh98769fjdla
"""
content = input('请输入内容：')
print(content.count('h'))
"""

# 7.计算用户输入的内容中有几个 h 或 H 字符？
# 如：content = input("请输入内容：") # 如fhdal234slfH9H769fjdla
"""
content = input('请输入内容:')
print(content.upper().count('H'))
"""

# 8.使用while循环分别正向和反向对字符串 message = "伤情最是晚凉天，憔悴厮人不堪言。" 进行打印。
"""
message = "伤情最是晚凉天，憔悴厮人不堪言。"
for i in range(0, len(message)):
    print(message[i])
for i in range(len(message) - 1, -1, -1):
    print(message[i])
"""

# 9.获取用户输入的内容中 前4个字符中 有几个 A ？
# 如：content = input("请输入内容：") # 如fAdal234slfH9H769fjdla
"""
content = input("请输入内容：")
print(content.count('A', 0, 4))
"""
# 10.获取用户输入的内容，并计算前四位"l"出现几次,并输出结果。
"""
content = input('请输入内容：')
print(content.count('l', 0, 4))
"""

# 11.获取用户两次输入的内容，并将所有的数据获取并进行相加，如：
# 要求：
# 	将num1中的的所有数字找到并拼接起来：1232312
# 	将num1中的的所有数字找到并拼接起来：1218323
# 	然后将两个数字进行相加。
"""
num1 = input("请输入：") # asdfd123sf2312
num2 = input("请输入：") # a12dfd183sf23
s1 = ''
s2 = ''
for i in num1:
    if i.isdigit():
        s1 += i
for i in num2:
    if i.isdigit():
        s2 += i
print(int(s1) + int(s2))
"""

# day 04
# 1.简述解释性语言和编译型语言的区别？
'''
解释性语言：是在执行时是解释一条一句，交给计算机处理一条语句。
编译性语言：是在程序编译完成后交给计算机统一处理。
'''

# 2.列举你了解的Python的数据类型？
'''
int/str/list/tuple/dict/set
'''

# 3.写代码，有如下列表，按照要求实现每一个功能。
# 计算列表的长度并输出
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
print(len(li))
'''
# 请通过步长获取索引为偶数的所有值，并打印出获取后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
print(li[0::2])
'''

# 列表中追加元素"seven",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.append('seven')
print(li)
'''

# 请在列表的第1个位置插入元素"Tony",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.insert(1, 'Tony')
print(li)
'''

# 请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li[2] = 'Kelly'
print(li)
'''

# 请将列表的第3个位置的值改成 "太白"，并输出修改后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li[3] = '太白'
print(li)
'''

# 请将列表 l2=[1,"a",3,4,"heart"] 的每一个元素追加到列表li中，并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
l2 = [1, "a", 3, 4, "heart"]
for i in l2:
    li.append(i)
print(li)
'''

# 请将字符串 s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
s = "qwert"
li.extend(s)
print(li)
'''

# 请删除列表中的元素"ritian",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.remove('ritian')
print(li)
'''

# 请删除列表中的第2个元素，并输出删除元素后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
del li[2]
print(li)
'''

# 请删除列表中的第2至第4个元素，并输出删除元素后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
del li[2:5]
print(li)
'''

# 4.请用三种方法实现字符串反转 name = "小黑半夜三点在被窝玩愤怒的小鸟"（步长、while、for）
'''
name = "小黑半夜三点在被窝玩愤怒的小鸟"
print(name[-1::-1])
'''
'''
name = "小黑半夜三点在被窝玩愤怒的小鸟"
l = ''
count = len(name) - 1
while count >= 0:
    l += name[count]
    count -= 1
print(l)
'''
'''
name = "小黑半夜三点在被窝玩愤怒的小鸟"
l = ''
for i in range(len(name), 0, -1):
    l += name[i-1]
print(l)
'''

# 5.写代码，有如下列表，利用切片实现每一个功能
# 通过对li列表的切片形成新的列表 [1,3,2]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
ls = li[0:3]
print(ls)
'''

# 通过对li列表的切片形成新的列表 ["a",4,"b"]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
ls = li[3:6]
print(ls)
'''

# 通过对li列表的切片形成新的列表 [1,2,4,5]
'''
li = [1, 3, 2, "a", 4, "b", 5, "c"]
ls = li[0::2]
print(ls)
'''

# 通过对li列表的切片形成新的列表 [3,"a","b"]
'''
li = [1, 3, 2, "a", 4, "b", 5, "c"]
ls = li[1:-2:2]
print(ls)
'''

# 通过对li列表的切片形成新的列表 [3,"a","b","c"]
'''
li = [1, 3, 2, "a", 4, "b", 5, "c"]
ls = li[1::2]
print(ls)
'''

# 通过对li列表的切片形成新的列表 ["c"]
'''
li = [1, 3, 2, "a", 4, "b", 5, "c"]
ls = li[-1]
print(ls)
'''

# 通过对li列表的切片形成新的列表 ["b","a",3]
'''
li = [1, 3, 2, "a", 4, "b", 5, "c"]
ls = li[-3::-2]
print(ls)
'''

# 6.请用代码实现循环输出元素和值：users = ["武沛齐","景女神","肖大侠"] ，如：
'''
users = ["武沛齐", "景女神", "肖大侠"]
count = 0
for i in users:
    print(count, i)
    count += 1
'''

# 7. 请用代码实现循环输出元素和值：users = ["武沛齐","景女神","肖大侠"] ，如：
'''
users = ["武沛齐", "景女神", "肖大侠"]
count = 1
for i in users:
    print(count, i)
    count += 1
'''

# 8.写代码，有如下列表，按照要求实现每一个功能。
# 将列表lis中的"k"变成大写，并打印列表。
'''
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[2] = 'K'
print(lis)
'''

# 将列表中的数字3变成字符串"100"
'''
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3][2][1][1] = '100'
print(lis)
'''

# 将列表中的字符串"tt"变成数字 101
'''
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3][2][1][0] = 101
print(lis)
'''

# 在 "qwe"前面插入字符串："火车头"
'''
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3].insert(0, '火车头')
print(lis)
'''

# 9.写代码实现以下功能
# 如有变量 googs = ['汽车','飞机','火箭'] 提示用户可供选择的商品：
'''
googs = ['汽车', '飞机', '火箭']
print('您可以选择的商品是')
for i in range(0, len(googs)):
    print(i ,googs[i])
'''

# 用户输入索引后，将指定商品的内容拼接打印，如：用户输入0，则打印 您选择的商品是汽车。
'''
googs = ['汽车', '飞机', '火箭']
for i in range(0, len(googs)):
    print(i, googs[i])
s = input('您可以选择以上商品:')
print('您选择的商品是%s' % (googs[int(s)]))
'''

# 10.利用下划线将列表的每一个元素拼接成字符串"a_l_e_x"
'''
li = "alex"
print('_'.join(li))
'''

# 11.利用for循环和range找出 0 ~ 100 以内所有的偶数，并追加到一个列表。
'''
ls = list()
for i in range(0, 100):
    if i % 2 == 0:
        ls.append(i)
print(ls)
'''

# 12.利用for循环和range 找出 0 ~ 50 以内能被3整除的数，并追加到一个列表。
'''
ls = list()
for i in range(0, 50):
    if i % 3 == 0:
        ls.append(i)
print(ls)
'''

# 13.利用for循环和range 找出 0 ~ 50 以内能被3整除的数，并插入到列表的第0个索引位置
'''
ls = list()
for i in range(0, 50):
    if i % 3 == 0:
        ls.insert(0, i)
print(ls)
'''

# 14.查找列表li中的元素，移除每个元素的空格，并找出以"a"开头，并添加到一个新列表中,最后循环打印这个新列表。
'''
ls = list()
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]
for i in range(0, len(li)):
    li[i] = li[i].strip()
    if li[i].startswith('a'):
        ls.append(li[i])
print(ls)
'''

# 15.判断是否可以实现，如果可以请写代码实现。
# 请将 "WuSir" 修改成 "武沛齐"
'''
li = ["alex", [11, 22, (88, 99, 100,), 33], "WuSir", ("ritian", "barry",), "wenzhou"]
li[2] = '武沛齐'
print(li)
'''

# 请将 ("ritian", "barry",) 修改为 ['日天','日地']
'''
li = ["alex", [11, 22, (88, 99, 100,), 33], "WuSir", ("ritian", "barry",), "wenzhou"]
li[3] = ['日天', '日地']
print(li)
'''

# 请将 88 修改为 87
'''
False
'''

# 请将 "wenzhou" 删除，然后再在列表第0个索引位置插入 "文周"
'''
li = ["alex", [11, 22, (88, 99, 100,), 33], "WuSir", ("ritian", "barry",), "wenzhou"]
li.remove('wenzhou')
li.insert(0, '文周')
print(li)
'''

# day 05
# 1.请将列表中的每个元素通过 "_" 链接起来。
'''
users = ['李少奇', '李启航', '渣渣辉']
print('_'.join(users))
'''

# 2.请将列表中的每个元素通过 "_" 链接起来。
'''
users = ['李少奇', '李启航', 666, '渣渣辉']
for i in range(0, len(users)):
    users[i] = str(users[i])
print('_'.join(users))
'''

# 3.请将元组 v1 = (11,22,33) 中的所有元素追加到列表 v2 = [44,55,66] 中。
'''
v1 = (11, 22, 33)
v2 = [44, 55, 66]
for i in v1:
    v2.append(i)
print(v2)
'''

# 4.请将元组 v1 = (11,22,33,44,55,66,77,88,99) 中的所有偶数索引位置的元素 追加到列表 v2 = [44,55,66] 中。
'''
v1 = (11, 22, 33, 44, 55, 66, 77, 88, 99)
v2 = [44, 55, 66]
for i in range(0, len(v1)):
    if i % 2 == 0:
        v2.append(v1[i])
print(v2)
'''

# 5.将字典的键和值分别追加到 key_list 和 value_list 两个列表中
'''
key_list = []
value_list = []
info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
for k, v in info.items():
    key_list.append(k)
    value_list.append(v)
print(key_list)
print(value_list)
'''

# 6.字典dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# a. 请循环输出所有的key
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic:
    print(i)
'''

# b. 请循环输出所有的value
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic.values():
    print(i)
'''

# c. 请循环输出所有的key和value
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic.items():
    print(i)
'''

# d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k4'] = 'v4'
print(dic)
'''

# e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k1'] = 'alex'
print(dic)
'''

# f. 请在k3对应的值中追加一个元素 44，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k3'].append(44)
print(dic)
'''

# g. 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k3'].insert(1, 18)
print(dic)
'''

# 7.请循环打印k2对应的值中的每个元素。
'''
info = {
    'k1': 'v1',
    'k2': [('alex'), ('wupeiqi'), ('oldboy')],
}
for i in info['k2']:
    print(i)
'''

# 8.有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 {'k':1,'k1':2....}
'''
info = dict()
s = "k: 1|k1:2|k2:3 |k3 :4"
s1 = s.split('|')
for i in s1:
    k, v = i.split(':')
    info[k] = v
print(info)
'''

# 9.有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于 66 的值保存至字典的第一个key对应的列表中，
# 将小于 66 的值保存至第二个key对应的列表中。
'''
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
result = {'k1': [], 'k2': []}
for i in li:
    if i > 66:
        result['k1'].append(i)
    elif i < 66:
        result['k2'].append(i)
print(result)
'''

# 10.输出商品列表，用户输入序号，显示用户选中的商品
# 商品列表：
#   goods = [
# 		{"name": "电脑", "price": 1999},
# 		{"name": "鼠标", "price": 10},
# 		{"name": "游艇", "price": 20},
# 		{"name": "美女", "price": 998}
# 	]
# 要求:
# 1：页面显示 序号 + 商品名称 + 商品价格，如：
#       1 电脑 1999
#       2 鼠标 10
# 	  ...
# 2：用户输入选择的商品序号，然后打印商品名称及商品价格
# 3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
# 4：用户输入Q或者q，退出程序。
'''
goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998}
]
for i in range(0, len(goods)):
    print(i + 1, goods[i]['name'], goods[i]['price'])
while True:
    num = input('请输入商品序号（按Q退出）:')
    if num.upper() == 'Q':
        break
    if num.isdigit() and int(num) <= len(goods) and int(num) > 0:
        print(goods[int(num) - 1]['name'], goods[int(num) - 1]['price'])
        break
    else:
        print('您的输入有误，请重新输入')
        continue
'''

# 11.看代码写结果
'''
v = {}
for index in range(10):
    v['users'] = index
print(v) # {'users': 9}
'''

# day 06
# 1.列举你了解的字典中的功能（字典独有）。
'''
dict().keys() # 列出dict中的键
dict().values() # 列出dict中的值
dict().items() # 列出dict中的键值对
dict().get() # 列出对应键的值，如果不存在则返回None
dict().update() # 更新键对应的值，如果键不存在则创建一个键并返回None，如果键存在则更新值
dict().pop() # 使用下标删除dict中的值，并可以赋值给一个变量
dict().clear() # 清空dict
'''

# 2.列举你了解的集合中的功能（集合独有）。
'''
set().add()  # 在set中添加一个元素
set().intersection()  # 交集
set().union()  # 并集
set().difference()  # 差集
set().symmetric_difference()  # 对称差集
set().update()  # 批量添加集合
set().clear()  # 清空集合
set().remove()  # 删除一个元素
'''

# 3.列举你了解的可以转换为 布尔值且为False的值。
'''
0/str()/list()/tuple()/dice()/set()
'''

# 4.请用代码实现
# 循环提示用户输入，根据用户输入的值为键去字典中获取对应的值并输出。
'''
info = {'name': '王刚蛋', 'hobby': '铁锤'}
while True:
    k = input('请输入内容：')
    print(info[k])
'''

# 循环提示用户输入，根据用户输入的值为键去字典中获取对应的值并输出
# （如果key不存在，则获取默认“键不存在”，并输出）。 注意：无需考虑循环终止（写死循环即可）
'''
info = {'name': '王刚蛋', 'hobby': '铁锤'}
while True:
    k = input('请输入内容：')
    print(info.get(k, '键不存在'))
'''

# 5.请用代码验证 "name" 是否在字典的键中？
'''
info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'}
print(info.get('name'))
'''

# 6.请用代码验证 "alex" 是否在字典的值中？
'''
info = {'name': '王刚蛋', 'hobby': '铁锤', 'age': '18'}
if 'alex' in info.values():
    print('alex')
else:
    print('False')
'''

# 7.请得到 v1 和 v2 的交集并输出
'''
v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
print(v1.intersection(v2))
'''

# 请得到 v1 和 v2 的并集并输出
'''
v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
print(v1.union(v2))
'''

# 请得到 v1 和 v2 的 差集并输出
'''
v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
print(v1.difference(v2))
'''

# 请得到 v2 和 v1 的 差集并输出
'''
v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
print(v2.difference(v1))
'''

# 请得到 v1 和 v2 的 对称差集并输出
'''
v1 = {'武沛齐', '李杰', '太白', '景女神'}
v2 = {'李杰', '景女神'}
print(v1.symmetric_difference(v2))
'''

# 8.循环提示用户输入，并将输入内容追加到列表中（如果输入N或n则停止循环）
'''
ls = list()
while True:
    value = input('请输入内容：')
    if value.upper() == 'N':
        break
    else:
        ls.append(value)
print(ls)
'''

# 9.循环提示用户输入，并将输入内容添加到集合中（如果输入N或n则停止循环）
'''
info = set()
while True:
    value = input('请输入内容：')
    if value.upper() == 'N':
        break
    else:
        info.add(value)
print(info)
'''

# 10.循环提示用户输入，如果输入值在v1中存在，则追加到v2中，
# 如果v1中不存在，则添加到v1中。（如果输入N或n则停止循环）
'''
v1 = {'alex', '武sir', '肖大'}
v2 = []

while True:
    value = input('请输入内容：')
    if value.upper() == 'N':
        break
    elif value in v1:
        v2.append(value)
    elif value not in v1:
        v1.add(value)
print(v1)
print(v2)
'''

# 11.判断以下值那个能做字典的key ？那个能做集合的元素？
'''
1   # True
-1  # True
""  # True
None    # True
[1,2]   # False
(1,)    # True
{11,22,33,4}    # False
{'name':'wupeiq','age':18}  # False
'''

# 12.is 和 == 的区别？
'''
is 是对比内存地址是否相同
== 是对比数据是否相同
'''

# 13.type使用方式及作用？
'''
type() # 括号内可以添加数据并判断是int/str/list/tuple/dict/set/哪种数据类型。
'''

# 14.id的使用方式及作用？
'''
id()括号内可以添加数据，并查询数据所在内存的位置。
'''

# 15.看代码写结果并解释原因
'''
v1 = {'k1': 'v1', 'k2': [1, 2, 3]}
v2 = {'k1': 'v1', 'k2': [1, 2, 3]}

result1 = v1 == v2
result2 = v1 is v2
print(result1)    # True 数据相同
print(result2)    # False 内存所在位置不同
'''

# 16.看代码写结果并解释原因
'''
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = v1

result1 = v1 == v2
result2 = v1 is v2
print(result1)  # True 数据相同
print(result2)  # True 内存位置相同
'''

# 17.看代码写结果并解释原因
'''
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = v1

v1['k1'] = 'wupeiqi'
print(v2)   # {'k1': 'wupeiqi', 'k2': [1, 2, 3]}    因为内存地址相同，而且v1是在原来的基础上进行修改，不是重新赋值。
'''

# 18.看代码写结果并解释原因
'''
v1 = '人生苦短，我用Python'
v2 = [1,2,3,4,v1]

v1 = "人生苦短，用毛线Python"

print(v2)   # [1, 2, 3, 4, '人生苦短，我用Python']     因为v1是重新赋值，不影响原来的内存地址数据
'''

# 19.看代码写结果并解释原因
'''
info = [1,2,3]
userinfo = {'account':info, 'num':info, 'money':info}

info.append(9)
print(userinfo) # {'account': [1, 2, 3, 9], 'num': [1, 2, 3, 9], 'money': [1, 2, 3, 9]}
                # 因为info修改他的数据，所以userinfo一起发生变化。
'''

# 20.看代码写结果并解释原因
'''
info = [1, 2, 3]
userinfo = [info, info, info, info, info]

info[0] = '不仅多，还特么难呢'
print(info, userinfo)   # ['不仅多，还特么难呢', 2, 3] info修改数据，不是重新赋值。
'''

# 21.看代码写结果并解释原因
'''
info = [1, 2, 3]
userinfo = [info, info, info, info, info]

userinfo[2][0] = '闭嘴'
print(info, userinfo)   # ['闭嘴', 2, 3] info修改数据，不是重新赋值。
'''

# 22.看代码写结果并解释原因
'''
info = [1, 2, 3]
user_list = []
for item in range(10):
    user_list.append(info)

info[1] = "是谁说Python好学的？"

print(user_list)    # [1, '是谁说Python好学的？', 3] 因为info是修改数据，不是重新赋值。
'''

# 23.看代码写结果并解释原因
'''
data = {}
for item in range(10):
    data['user'] = item
print(data) # {'user': 9} 因为每一次都是重新赋值
'''

# 24.看代码写结果并解释原因
'''
data_list = []
data = {}
for item in range(10):
    data['user'] = item
    data_list.append(data)
print(data_list)   
[{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, 
{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}]
# 因为list获取的合data是同一个内存地址，而data是改变他的数据，所以之前添加的数据也会跟着改变。
'''

# 25.看代码写结果并解释原因
'''
data_list = []
for item in range(10):
    data = {}
    data['user'] = item
    data_list.append(data)
print(data_list)
[{'user': 0}, {'user': 1}, {'user': 2}, {'user': 3}, {'user': 4}, 
 {'user': 5}, {'user': 6}, {'user': 7}, {'user': 8}, {'user': 9}]
 因为data是重新赋值他的数据，所以之前添加的数据不会跟着改变。
'''